// #include <pthread.h>
// #include <stdio.h>
// #include <stdlib.h>

// void* print_message(void* arg) {
//     pthread_t id =pthread_self();
//     printf("子线程id: %ld\n",id);
//     char* msg = (char*)arg;
//     printf("Thread says: %s\n", msg);
//     return NULL;
// }

// int main() {
//     pthread_t tid;
//     char* message = "Hello from thread!";
    
//     // 创建线程（使用默认属性）
//     if (pthread_create(&tid, NULL, print_message, message) != 0) {
//         perror("Failed to create thread");
//         return 1;
//     }

//     pthread_t id =pthread_self();
//     printf("主线程id: %ld\n",id);

//     // 主线程继续执行
//     printf("Main thread continues...\n");
    
//     // 等待子线程结束（避免主线程提前退出）
//     pthread_join(tid, NULL);
//     return 0;
// }


// #include <stdio.h>
// #include <stdlib.h>
// #include <pthread.h>
// #include <string.h>

// // 线程函数：计算字符串长度并返回
// void* str_len_thread(void* arg) {
//     const char* str = (const char*)arg;
//     size_t len = strlen(str);
//     // 分配堆内存存储结果
//     size_t* result = (size_t*)malloc(sizeof(size_t));
//     *result = len;
//     pthread_exit(result); // 返回堆内存指针
// }

// int main() {
//     pthread_t tid;
//     const char* text = "Hello, pthread_exit!";
    
//     // 创建线程
//     if (pthread_create(&tid, NULL, str_len_thread, (void*)text) != 0) {
//         perror("pthread_create failed");
//         return 1;
//     }

//     // 等待线程结束并获取返回值
//     void* retval;
//     if (pthread_join(tid, &retval) != 0) {
//         perror("pthread_join failed");
//         return 1;
//     }

//     // 输出结果并释放堆内存
//     printf("String length: %zu\n", *(size_t*)retval);
//     free(retval);
//     return 0;
// }


// #include <stdio.h>
// #include <pthread.h>
// #include <unistd.h>

// void* thread_func(void* arg) {
//     printf("Thread started. Working...\n");
//     // 模拟长时间运行的任务（非取消点）
//     while (1) {
//         sleep(1);
//         printf("Working...\n");
//     }
//     return NULL;
// }

// int main() {
//     pthread_t tid;
//     pthread_create(&tid, NULL, thread_func, NULL);

//     sleep(2); // 等待线程运行
//     pthread_cancel(tid); // 发送取消请求

//     void* retval;
//     pthread_join(tid, &retval); // 等待线程终止

//     if (retval == PTHREAD_CANCELED) {
//         printf("Thread was canceled.\n");
//     } else {
//         printf("Thread exited normally.\n");
//     }

//     return 0;
// }

// #include <stdio.h>
// #include <stdlib.h>
// #include <pthread.h>

// // 线程函数：计算1到N的和并返回
// void* sum_thread(void* arg) {
//     int n = *(int*)arg;
//     int sum = 0;
//     for (int i = 1; i <= n; ++i) {
//         sum += i;
//     }
//     // 返回堆内存指针（需外部释放）
//     int* result = (int*)malloc(sizeof(int));
//     *result = sum;
//     pthread_exit(result);
// }

// int main() {
//     pthread_t tid;
//     int n = 10;

//     // 创建线程
//     if (pthread_create(&tid, NULL, sum_thread, &n) != 0) {
//         perror("pthread_create failed");
//         return 1;
//     }

//     // 等待线程结束并获取返回值
//     void* retval;
//     if (pthread_join(tid, &retval) != 0) {
//         perror("pthread_join failed");
//         return 1;
//     }

//     // 输出结果并释放堆内存
//     int sum = *(int*)retval;
//     printf("Sum of 1 to %d: %d\n", n, sum);
//     free(retval);
//     return 0;
// }


// #include <stdio.h>
// #include <pthread.h>
// #include <unistd.h>

// // 线程函数：后台任务（无需返回值）
// void* background_task(void* arg) {
//     printf("Background thread started. Working...\n");
//     sleep(2); // 模拟耗时操作
//     printf("Background thread finished.\n");
//     return NULL; // 返回值无法被获取
// }

// // 案例1：子线程操作时间较短
// // void* child_thread(void* arg) {
// //     printf("Child thread started. Working...\n");
// //     sleep(1); // 缩短睡眠时间
// //     printf("Child thread finished.\n");
// //     return (void*)42;
// // }

// // // 案例2：子线程操作时间较长
// // void* child_thread(void* arg) {
// //     printf("Child thread started. Working...\n");
// //     sleep(10); // 延长睡眠时间
// //     printf("Child thread finished.\n");
// //     return (void*)42;
// // }

// int main() {
//     pthread_t tid;
//     // 创建线程并立即分离
//     if (pthread_create(&tid, NULL,background_task, NULL) != 0) {
//         perror("pthread_create failed");
//         return 1;
//     }

//     if (pthread_detach(tid) != 0) {
//         perror("pthread_detach failed");
//         return 1;
//     }

//     // 主线程继续执行其他任务
//     printf("Main thread continues...\n");
//     sleep(3); // 确保子线程有机会运行
//     return 0;
// }


